home *** CD-ROM | disk | FTP | other *** search
/ Motor Sport Digital Archive Collection 1960s / Motor Sport Digital Archive Collection 1960s.iso / main.swf / scripts / mx / core / ScrollControlBase.as < prev    next >
Encoding:
Text File  |  2008-05-21  |  22.7 KB  |  643 lines
  1. package mx.core
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Graphics;
  5.    import flash.display.Shape;
  6.    import flash.events.Event;
  7.    import flash.events.MouseEvent;
  8.    import flash.geom.Point;
  9.    import mx.controls.HScrollBar;
  10.    import mx.controls.ToolTip;
  11.    import mx.controls.VScrollBar;
  12.    import mx.controls.scrollClasses.ScrollBar;
  13.    import mx.events.ScrollEvent;
  14.    import mx.events.ScrollEventDetail;
  15.    import mx.events.ScrollEventDirection;
  16.    import mx.managers.ToolTipManager;
  17.    import mx.skins.RectangularBorder;
  18.    import mx.styles.ISimpleStyleClient;
  19.    
  20.    use namespace mx_internal;
  21.    
  22.    public class ScrollControlBase extends UIComponent
  23.    {
  24.       mx_internal static const VERSION:String = "2.0.1.0";
  25.       
  26.       protected var maskShape:Shape;
  27.       
  28.       protected var border:IFlexDisplayObject;
  29.       
  30.       protected var scrollAreaChanged:Boolean;
  31.       
  32.       private var _viewMetrics:EdgeMetrics;
  33.       
  34.       private var numberOfRows:Number = 0;
  35.       
  36.       private var viewableColumns:Number;
  37.       
  38.       private var _scrollTipFunction:Function;
  39.       
  40.       private var numberOfCols:Number = 0;
  41.       
  42.       private var oldTTMEnabled:Boolean;
  43.       
  44.       mx_internal var _maxHorizontalScrollPosition:Number;
  45.       
  46.       public var liveScrolling:Boolean = true;
  47.       
  48.       private var scrollThumbMidPoint:Number;
  49.       
  50.       protected var horizontalScrollBar:ScrollBar;
  51.       
  52.       private var invLayout:Boolean;
  53.       
  54.       public var showScrollTips:Boolean = false;
  55.       
  56.       private var scrollTip:ToolTip;
  57.       
  58.       mx_internal var _maxVerticalScrollPosition:Number;
  59.       
  60.       protected var verticalScrollBar:ScrollBar;
  61.       
  62.       private var propsInited:Boolean;
  63.       
  64.       mx_internal var _verticalScrollPosition:Number = 0;
  65.       
  66.       private var specialHScrollCase:Boolean;
  67.       
  68.       mx_internal var _horizontalScrollPosition:Number = 0;
  69.       
  70.       mx_internal var _horizontalScrollPolicy:String = "off";
  71.       
  72.       mx_internal var _verticalScrollPolicy:String = "auto";
  73.       
  74.       private var viewableRows:Number;
  75.       
  76.       public function ScrollControlBase()
  77.       {
  78.          numberOfCols = 0;
  79.          numberOfRows = 0;
  80.          mx_internal::_horizontalScrollPosition = 0;
  81.          mx_internal::_horizontalScrollPolicy = ScrollPolicy.OFF;
  82.          liveScrolling = true;
  83.          showScrollTips = false;
  84.          mx_internal::_verticalScrollPosition = 0;
  85.          mx_internal::_verticalScrollPolicy = ScrollPolicy.AUTO;
  86.          super();
  87.          _viewMetrics = EdgeMetrics.EMPTY;
  88.          addEventListener(MouseEvent.MOUSE_WHEEL,mouseWheelHandler);
  89.       }
  90.       
  91.       protected function setScrollBarProperties(param1:int, param2:int, param3:int, param4:int) : void
  92.       {
  93.          var _loc5_:String = null;
  94.          var _loc6_:String = null;
  95.          _loc5_ = this.horizontalScrollPolicy;
  96.          _loc6_ = this.verticalScrollPolicy;
  97.          scrollAreaChanged = false;
  98.          if(_loc5_ == ScrollPolicy.ON || param2 < param1 && param1 > 0 && _loc5_ == ScrollPolicy.AUTO)
  99.          {
  100.             if(!horizontalScrollBar || specialHScrollCase)
  101.             {
  102.                specialHScrollCase = false;
  103.                if(!horizontalScrollBar)
  104.                {
  105.                   if(createHScrollBar())
  106.                   {
  107.                      horizontalScrollBar.visible = false;
  108.                      horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollHandler);
  109.                      horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollTipHandler);
  110.                      horizontalScrollBar.scrollPosition = mx_internal::_horizontalScrollPosition;
  111.                      scrollAreaChanged = true;
  112.                   }
  113.                }
  114.             }
  115.             if(Boolean(horizontalScrollBar) && (numberOfCols != param1 || viewableColumns != param2 || scrollAreaChanged))
  116.             {
  117.                horizontalScrollBar.setScrollProperties(param2,0,param1 - param2);
  118.                if(horizontalScrollBar.scrollPosition != mx_internal::_horizontalScrollPosition)
  119.                {
  120.                   horizontalScrollBar.scrollPosition = mx_internal::_horizontalScrollPosition;
  121.                }
  122.                viewableColumns = param2;
  123.                numberOfCols = param1;
  124.             }
  125.          }
  126.          else if((_loc5_ == ScrollPolicy.AUTO || _loc5_ == ScrollPolicy.OFF) && Boolean(horizontalScrollBar))
  127.          {
  128.             horizontalScrollPosition = 0;
  129.             removeChild(horizontalScrollBar);
  130.             horizontalScrollBar = null;
  131.             viewableColumns = NaN;
  132.             scrollAreaChanged = true;
  133.          }
  134.          if(_loc6_ == ScrollPolicy.ON || param4 < param3 && param3 > 0 && _loc6_ == ScrollPolicy.AUTO)
  135.          {
  136.             if(!verticalScrollBar)
  137.             {
  138.                if(createVScrollBar())
  139.                {
  140.                   verticalScrollBar.visible = false;
  141.                   verticalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollHandler);
  142.                   verticalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollTipHandler);
  143.                   verticalScrollBar.scrollPosition = mx_internal::_verticalScrollPosition;
  144.                   scrollAreaChanged = true;
  145.                }
  146.             }
  147.             if(Boolean(verticalScrollBar) && (numberOfRows != param3 || viewableRows != param4 || scrollAreaChanged))
  148.             {
  149.                verticalScrollBar.setScrollProperties(param4,0,param3 - param4);
  150.                if(verticalScrollBar.scrollPosition != mx_internal::_verticalScrollPosition)
  151.                {
  152.                   verticalScrollBar.scrollPosition = mx_internal::_verticalScrollPosition;
  153.                }
  154.                viewableRows = param4;
  155.                numberOfRows = param3;
  156.             }
  157.          }
  158.          else if((_loc6_ == ScrollPolicy.AUTO || _loc6_ == ScrollPolicy.OFF) && Boolean(verticalScrollBar))
  159.          {
  160.             verticalScrollPosition = 0;
  161.             removeChild(verticalScrollBar);
  162.             verticalScrollBar = null;
  163.             viewableRows = NaN;
  164.             scrollAreaChanged = true;
  165.          }
  166.          if(scrollAreaChanged)
  167.          {
  168.             updateDisplayList(unscaledWidth,unscaledHeight);
  169.          }
  170.       }
  171.       
  172.       [Bindable("viewChanged")]
  173.       [Bindable("scroll")]
  174.       public function get verticalScrollPosition() : Number
  175.       {
  176.          return mx_internal::_verticalScrollPosition;
  177.       }
  178.       
  179.       protected function createBorder() : void
  180.       {
  181.          var _loc1_:Class = null;
  182.          if(!border && isBorderNeeded())
  183.          {
  184.             _loc1_ = getStyle("borderSkin");
  185.             border = new _loc1_();
  186.             if(border is IUIComponent)
  187.             {
  188.                IUIComponent(border).enabled = enabled;
  189.             }
  190.             if(border is ISimpleStyleClient)
  191.             {
  192.                ISimpleStyleClient(border).styleName = this;
  193.             }
  194.             addChildAt(DisplayObject(border),0);
  195.             invalidateDisplayList();
  196.          }
  197.       }
  198.       
  199.       [Bindable("viewChanged")]
  200.       [Bindable("scroll")]
  201.       public function get horizontalScrollPosition() : Number
  202.       {
  203.          return mx_internal::_horizontalScrollPosition;
  204.       }
  205.       
  206.       private function createVScrollBar() : ScrollBar
  207.       {
  208.          var _loc1_:EdgeMetrics = null;
  209.          var _loc2_:VScrollBar = null;
  210.          var _loc3_:String = null;
  211.          _loc1_ = borderMetrics;
  212.          _loc2_ = new VScrollBar();
  213.          if(unscaledWidth >= _loc2_.minWidth + _loc1_.left + _loc1_.right)
  214.          {
  215.             verticalScrollBar = _loc2_;
  216.             verticalScrollBar.enabled = enabled;
  217.             _loc3_ = getStyle("verticalScrollBarStyleName");
  218.             verticalScrollBar.styleName = _loc3_;
  219.             addChild(verticalScrollBar);
  220.          }
  221.          return verticalScrollBar;
  222.       }
  223.       
  224.       [Bindable("scrollTipFunctionChanged")]
  225.       public function get scrollTipFunction() : Function
  226.       {
  227.          return _scrollTipFunction;
  228.       }
  229.       
  230.       public function set verticalScrollPosition(param1:Number) : void
  231.       {
  232.          mx_internal::_verticalScrollPosition = param1;
  233.          if(verticalScrollBar)
  234.          {
  235.             verticalScrollBar.scrollPosition = param1;
  236.          }
  237.          dispatchEvent(new Event("viewChanged"));
  238.       }
  239.       
  240.       private function createHScrollBar() : ScrollBar
  241.       {
  242.          var _loc1_:EdgeMetrics = null;
  243.          var _loc2_:HScrollBar = null;
  244.          var _loc3_:String = null;
  245.          _loc1_ = borderMetrics;
  246.          _loc2_ = new HScrollBar();
  247.          if(unscaledHeight >= _loc2_.minHeight + _loc1_.top + _loc1_.bottom)
  248.          {
  249.             horizontalScrollBar = _loc2_;
  250.             horizontalScrollBar.enabled = enabled;
  251.             _loc3_ = getStyle("horizontalScrollBarStyleName");
  252.             horizontalScrollBar.styleName = _loc3_;
  253.             addChild(horizontalScrollBar);
  254.             horizontalScrollBar.validateNow();
  255.          }
  256.          return horizontalScrollBar;
  257.       }
  258.       
  259.       [Bindable("horizontalScrollPolicyChanged")]
  260.       public function get horizontalScrollPolicy() : String
  261.       {
  262.          return mx_internal::_horizontalScrollPolicy;
  263.       }
  264.       
  265.       public function set horizontalScrollPosition(param1:Number) : void
  266.       {
  267.          mx_internal::_horizontalScrollPosition = param1;
  268.          if(horizontalScrollBar)
  269.          {
  270.             horizontalScrollBar.scrollPosition = param1;
  271.          }
  272.          dispatchEvent(new Event("viewChanged"));
  273.       }
  274.       
  275.       private function scrollTipHandler(param1:Event) : void
  276.       {
  277.          var _loc2_:ScrollBar = null;
  278.          var _loc3_:* = false;
  279.          var _loc4_:String = null;
  280.          var _loc5_:Number = NaN;
  281.          var _loc6_:String = null;
  282.          var _loc7_:Point = null;
  283.          if(param1 is ScrollEvent)
  284.          {
  285.             if(!showScrollTips)
  286.             {
  287.                return;
  288.             }
  289.             if(ScrollEvent(param1).detail == ScrollEventDetail.THUMB_POSITION)
  290.             {
  291.                if(scrollTip)
  292.                {
  293.                   systemManager.toolTipChildren.removeChild(scrollTip);
  294.                   scrollTip = null;
  295.                   ToolTipManager.enabled = oldTTMEnabled;
  296.                }
  297.             }
  298.             else if(ScrollEvent(param1).detail == ScrollEventDetail.THUMB_TRACK)
  299.             {
  300.                _loc2_ = ScrollBar(param1.target);
  301.                _loc3_ = _loc2_ == verticalScrollBar;
  302.                _loc4_ = _loc3_ ? "vertical" : "horizontal";
  303.                _loc5_ = _loc2_.scrollPosition;
  304.                if(!scrollTip)
  305.                {
  306.                   scrollTip = new ToolTip();
  307.                   systemManager.toolTipChildren.addChild(scrollTip);
  308.                   scrollThumbMidPoint = _loc2_.mx_internal::scrollThumb.height / 2;
  309.                   oldTTMEnabled = ToolTipManager.enabled;
  310.                   ToolTipManager.enabled = false;
  311.                }
  312.                _loc6_ = _loc5_.toString();
  313.                if(_scrollTipFunction != null)
  314.                {
  315.                   _loc6_ = _scrollTipFunction(_loc4_,_loc5_);
  316.                }
  317.                if(_loc6_ == "")
  318.                {
  319.                   scrollTip.visible = false;
  320.                }
  321.                else
  322.                {
  323.                   scrollTip.text = _loc6_;
  324.                   ToolTipManager.mx_internal::sizeTip(scrollTip);
  325.                   _loc7_ = new Point();
  326.                   if(_loc3_)
  327.                   {
  328.                      _loc7_.x = -3 - scrollTip.width;
  329.                      _loc7_.y = _loc2_.mx_internal::scrollThumb.y + scrollThumbMidPoint - scrollTip.height / 2;
  330.                   }
  331.                   else
  332.                   {
  333.                      _loc7_.x = -3 - scrollTip.height;
  334.                      _loc7_.y = _loc2_.mx_internal::scrollThumb.y + scrollThumbMidPoint - scrollTip.width / 2;
  335.                   }
  336.                   _loc7_ = _loc2_.localToGlobal(_loc7_);
  337.                   scrollTip.move(_loc7_.x,_loc7_.y);
  338.                   scrollTip.visible = true;
  339.                }
  340.             }
  341.          }
  342.       }
  343.       
  344.       protected function mouseWheelHandler(param1:MouseEvent) : void
  345.       {
  346.          var _loc2_:int = 0;
  347.          var _loc3_:Number = NaN;
  348.          var _loc4_:Number = NaN;
  349.          var _loc5_:ScrollEvent = null;
  350.          if(verticalScrollBar)
  351.          {
  352.             param1.stopPropagation();
  353.             _loc2_ = param1.delta <= 0 ? 1 : -1;
  354.             _loc3_ = Math.max(Math.abs(param1.delta),verticalScrollBar.lineScrollSize);
  355.             _loc4_ = verticalScrollPosition;
  356.             verticalScrollPosition += 3 * _loc3_ * _loc2_;
  357.             _loc5_ = new ScrollEvent(ScrollEvent.SCROLL);
  358.             _loc5_.direction = ScrollEventDirection.VERTICAL;
  359.             _loc5_.position = verticalScrollPosition;
  360.             _loc5_.delta = verticalScrollPosition - _loc4_;
  361.             dispatchEvent(_loc5_);
  362.          }
  363.       }
  364.       
  365.       [Bindable("verticalScrollPolicyChanged")]
  366.       public function get verticalScrollPolicy() : String
  367.       {
  368.          return mx_internal::_verticalScrollPolicy;
  369.       }
  370.       
  371.       public function set scrollTipFunction(param1:Function) : void
  372.       {
  373.          _scrollTipFunction = param1;
  374.          dispatchEvent(new Event("scrollTipFunctionChanged"));
  375.       }
  376.       
  377.       public function set horizontalScrollPolicy(param1:String) : void
  378.       {
  379.          var _loc2_:String = null;
  380.          _loc2_ = param1.toLowerCase();
  381.          if(mx_internal::_horizontalScrollPolicy != _loc2_)
  382.          {
  383.             mx_internal::_horizontalScrollPolicy = _loc2_;
  384.             invalidateDisplayList();
  385.             dispatchEvent(new Event("horizontalScrollPolicyChanged"));
  386.          }
  387.       }
  388.       
  389.       private function isBorderNeeded() : Boolean
  390.       {
  391.          var _loc1_:Object = null;
  392.          _loc1_ = getStyle("borderStyle");
  393.          if(_loc1_)
  394.          {
  395.             if(_loc1_ != "none" || _loc1_ == "none" && getStyle("mouseShield"))
  396.             {
  397.                return true;
  398.             }
  399.          }
  400.          _loc1_ = getStyle("backgroundColor");
  401.          if(_loc1_ !== null && _loc1_ !== "")
  402.          {
  403.             return true;
  404.          }
  405.          _loc1_ = getStyle("backgroundImage");
  406.          return _loc1_ != null && _loc1_ != "";
  407.       }
  408.       
  409.       public function set maxVerticalScrollPosition(param1:Number) : void
  410.       {
  411.          mx_internal::_maxVerticalScrollPosition = param1;
  412.          dispatchEvent(new Event("maxVerticalScrollPositionChanged"));
  413.       }
  414.       
  415.       [Bindable("maxHorizontalScrollPositionChanged")]
  416.       public function get maxHorizontalScrollPosition() : Number
  417.       {
  418.          var _loc1_:Number = NaN;
  419.          if(!isNaN(mx_internal::_maxHorizontalScrollPosition))
  420.          {
  421.             return mx_internal::_maxHorizontalScrollPosition;
  422.          }
  423.          return !!horizontalScrollBar ? horizontalScrollBar.maxScrollPosition : 0;
  424.       }
  425.       
  426.       public function set verticalScrollPolicy(param1:String) : void
  427.       {
  428.          var _loc2_:String = null;
  429.          _loc2_ = param1.toLowerCase();
  430.          if(mx_internal::_verticalScrollPolicy != _loc2_)
  431.          {
  432.             mx_internal::_verticalScrollPolicy = _loc2_;
  433.             invalidateDisplayList();
  434.             dispatchEvent(new Event("verticalScrollPolicyChanged"));
  435.          }
  436.       }
  437.       
  438.       mx_internal function get scroll_horizontalScrollBar() : ScrollBar
  439.       {
  440.          return horizontalScrollBar;
  441.       }
  442.       
  443.       protected function layoutChrome(param1:Number, param2:Number) : void
  444.       {
  445.          if(border)
  446.          {
  447.             border.move(0,0);
  448.             border.setActualSize(param1,param2);
  449.          }
  450.       }
  451.       
  452.       mx_internal function get scroll_verticalScrollBar() : ScrollBar
  453.       {
  454.          return verticalScrollBar;
  455.       }
  456.       
  457.       public function get viewMetrics() : EdgeMetrics
  458.       {
  459.          _viewMetrics = borderMetrics.clone();
  460.          if(!horizontalScrollBar && horizontalScrollPolicy == ScrollPolicy.ON)
  461.          {
  462.             if(createHScrollBar())
  463.             {
  464.                horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollHandler);
  465.                horizontalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollTipHandler);
  466.                horizontalScrollBar.scrollPosition = mx_internal::_horizontalScrollPosition;
  467.                specialHScrollCase = true;
  468.                invalidateDisplayList();
  469.             }
  470.          }
  471.          if(!verticalScrollBar && verticalScrollPolicy == ScrollPolicy.ON)
  472.          {
  473.             if(createVScrollBar())
  474.             {
  475.                verticalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollHandler);
  476.                verticalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollTipHandler);
  477.                verticalScrollBar.scrollPosition = mx_internal::_verticalScrollPosition;
  478.                invalidateDisplayList();
  479.             }
  480.          }
  481.          if(verticalScrollBar)
  482.          {
  483.             _viewMetrics.right += verticalScrollBar.minWidth;
  484.          }
  485.          if(horizontalScrollBar)
  486.          {
  487.             _viewMetrics.bottom += horizontalScrollBar.minHeight;
  488.          }
  489.          return _viewMetrics;
  490.       }
  491.       
  492.       override public function set enabled(param1:Boolean) : void
  493.       {
  494.          super.enabled = param1;
  495.          if(horizontalScrollBar)
  496.          {
  497.             horizontalScrollBar.enabled = param1;
  498.          }
  499.          if(verticalScrollBar)
  500.          {
  501.             verticalScrollBar.enabled = param1;
  502.          }
  503.       }
  504.       
  505.       [Bindable("maxVerticalScrollPositionChanged")]
  506.       public function get maxVerticalScrollPosition() : Number
  507.       {
  508.          var _loc1_:Number = NaN;
  509.          if(!isNaN(mx_internal::_maxVerticalScrollPosition))
  510.          {
  511.             return mx_internal::_maxVerticalScrollPosition;
  512.          }
  513.          return !!verticalScrollBar ? verticalScrollBar.maxScrollPosition : 0;
  514.       }
  515.       
  516.       override protected function createChildren() : void
  517.       {
  518.          var _loc1_:Graphics = null;
  519.          super.createChildren();
  520.          createBorder();
  521.          if(!maskShape)
  522.          {
  523.             maskShape = new FlexShape();
  524.             maskShape.name = "mask";
  525.             _loc1_ = maskShape.graphics;
  526.             _loc1_.beginFill(16777215);
  527.             _loc1_.drawRect(0,0,10,10);
  528.             _loc1_.endFill();
  529.             addChild(maskShape);
  530.          }
  531.          maskShape.visible = false;
  532.       }
  533.       
  534.       public function get borderMetrics() : EdgeMetrics
  535.       {
  536.          return Boolean(border) && border is RectangularBorder ? RectangularBorder(border).borderMetrics : EdgeMetrics.EMPTY;
  537.       }
  538.       
  539.       protected function scrollHandler(param1:Event) : void
  540.       {
  541.          var _loc2_:ScrollBar = null;
  542.          var _loc3_:Number = NaN;
  543.          var _loc4_:QName = null;
  544.          if(param1 is ScrollEvent)
  545.          {
  546.             _loc2_ = ScrollBar(param1.target);
  547.             _loc3_ = _loc2_.scrollPosition;
  548.             if(_loc2_ == verticalScrollBar)
  549.             {
  550.                _loc4_ = new QName(mx_internal,"_verticalScrollPosition");
  551.             }
  552.             else if(_loc2_ == horizontalScrollBar)
  553.             {
  554.                _loc4_ = new QName(mx_internal,"_horizontalScrollPosition");
  555.             }
  556.             dispatchEvent(param1);
  557.             if(_loc4_)
  558.             {
  559.                this[_loc4_] = _loc3_;
  560.             }
  561.          }
  562.       }
  563.       
  564.       override public function styleChanged(param1:String) : void
  565.       {
  566.          var _loc2_:Boolean = false;
  567.          var _loc3_:String = null;
  568.          var _loc4_:String = null;
  569.          _loc2_ = param1 == null || param1 == "styleName";
  570.          super.styleChanged(param1);
  571.          if(_loc2_ || param1 == "horizontalScrollBarStyleName")
  572.          {
  573.             if(horizontalScrollBar)
  574.             {
  575.                _loc3_ = getStyle("horizontalScrollBarStyleName");
  576.                horizontalScrollBar.styleName = _loc3_;
  577.             }
  578.          }
  579.          if(_loc2_ || param1 == "verticalScrollBarStyleName")
  580.          {
  581.             if(verticalScrollBar)
  582.             {
  583.                _loc4_ = getStyle("verticalScrollBarStyleName");
  584.                verticalScrollBar.styleName = _loc4_;
  585.             }
  586.          }
  587.       }
  588.       
  589.       public function set maxHorizontalScrollPosition(param1:Number) : void
  590.       {
  591.          mx_internal::_maxHorizontalScrollPosition = param1;
  592.          dispatchEvent(new Event("maxHorizontalScrollPositionChanged"));
  593.       }
  594.       
  595.       override protected function updateDisplayList(param1:Number, param2:Number) : void
  596.       {
  597.          var _loc3_:Number = NaN;
  598.          var _loc4_:Number = NaN;
  599.          var _loc5_:EdgeMetrics = null;
  600.          var _loc6_:DisplayObject = null;
  601.          var _loc7_:Number = NaN;
  602.          var _loc8_:Number = NaN;
  603.          super.updateDisplayList(param1,param2);
  604.          layoutChrome(param1,param2);
  605.          if(verticalScrollBar == null && verticalScrollPolicy == ScrollPolicy.ON)
  606.          {
  607.             if(createVScrollBar())
  608.             {
  609.                verticalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollHandler);
  610.                verticalScrollBar.addEventListener(ScrollEvent.SCROLL,scrollTipHandler);
  611.                verticalScrollBar.scrollPosition = mx_internal::_verticalScrollPosition;
  612.             }
  613.          }
  614.          _loc3_ = param1;
  615.          _loc4_ = param2;
  616.          invLayout = false;
  617.          _loc5_ = _viewMetrics = viewMetrics;
  618.          if(horizontalScrollBar)
  619.          {
  620.             horizontalScrollBar.setActualSize(_loc3_ - _loc5_.left - _loc5_.right,horizontalScrollBar.minHeight);
  621.             horizontalScrollBar.move(_loc5_.left,_loc4_ - _loc5_.bottom);
  622.             horizontalScrollBar.visible = horizontalScrollBar.width >= horizontalScrollBar.minWidth && _loc4_ > horizontalScrollBar.height;
  623.             horizontalScrollBar.enabled = enabled;
  624.          }
  625.          if(verticalScrollBar)
  626.          {
  627.             verticalScrollBar.setActualSize(verticalScrollBar.minWidth,_loc4_ - _loc5_.top - _loc5_.bottom);
  628.             verticalScrollBar.move(_loc3_ - _loc5_.right,_loc5_.top);
  629.             verticalScrollBar.visible = verticalScrollBar.height >= verticalScrollBar.minHeight && _loc3_ > verticalScrollBar.width;
  630.             verticalScrollBar.enabled = enabled;
  631.          }
  632.          _loc6_ = maskShape;
  633.          _loc7_ = _loc3_ - _loc5_.left - _loc5_.right;
  634.          _loc8_ = _loc4_ - _loc5_.top - _loc5_.bottom;
  635.          _loc6_.width = _loc7_ < 0 ? 0 : _loc7_;
  636.          _loc6_.height = _loc8_ < 0 ? 0 : _loc8_;
  637.          _loc6_.x = _loc5_.left;
  638.          _loc6_.y = _loc5_.top;
  639.       }
  640.    }
  641. }
  642.  
  643.